// pages/repair/repair.js
const api = require('../../utils/api.js')
const config = require('../../utils/config.js')
const subscribe = require('../../utils/subscribe.js')
const app = getApp()

Page({
    data: {
        labId: '',
        labInfo: {},
        deviceTypes: config.deviceTypes,
        faultTypes: config.faultTypes,
        deviceTypeIndex: -1,
        faultTypeIndex: -1,
        description: '',
        images: [],
        maxImageCount: config.maxImageCount,
        remark: '',
        phone: '',
        submitting: false,
        // 资产相关字段
        assetId: null,
        assetInfo: null,
        isFromScan: false  // 标记是否通过扫码进入
    },

    onLoad(options) {
        options = options || {}

        // 检查登录状态
        if (!app.isLoggedIn()) {
            wx.showModal({
                title: '需要登录',
                content: '提交报修工单需要先登录',
                confirmText: '去登录',
                cancelText: '返回',
                success: res => {
                    if (res.confirm) {
                        wx.redirectTo({
                            url: '/pages/login/login'
                        })
                    } else {
                        // 如果是页面栈的唯一页面，则跳转到首页，否则返回上一页
                        const pages = getCurrentPages()
                        if (pages.length > 1) {
                            wx.navigateBack()
                        } else {
                            wx.switchTab({
                                url: '/pages/index/index'
                            })
                        }
                    }
                }
            })
            return
        }

        // 处理资产ID参数（扫码进入）
        if (options.assetId) {
            this.setData({
                assetId: options.assetId,
                isFromScan: true
            })
            this.loadAssetInfo(options.assetId)
        }

        // 处理机房ID参数（传统方式）
        if (options.labId) {
            this.setData({ labId: options.labId })
            this.loadLabInfo(options.labId)
        }

        // 如果有 labName，直接显示
        if (options.labName) {
            this.setData({
                labInfo: {
                    name: decodeURIComponent(options.labName),
                    location: options.location || ''
                }
            })
        }

        // 自动填充注册手机号
        if (app.globalData.userInfo && app.globalData.userInfo.phone) {
            this.setData({
                phone: app.globalData.userInfo.phone
            })
        }
    },

    // 加载机房信息
    loadLabInfo(labId) {
        api.getLabInfo(labId).then(res => {
            this.setData({
                labInfo: res
            })
        }).catch(err => {
            console.error('加载机房信息失败', err)
        })
    },

    // 加载资产信息（扫码进入后自动填充）
    loadAssetInfo(assetId) {
        wx.showLoading({ title: '加载设备信息...' })

        api.getAssetInfo(assetId).then(res => {
            wx.hideLoading()

            console.log('资产信息:', res)

            // 保存资产信息
            this.setData({
                assetInfo: res,
                labId: res.lab_id || '',
                labInfo: {
                    name: res.lab_name || '',
                    location: res.lab_location || ''
                }
            })

            // 根据资产类别自动匹配设备类型
            if (res.category_name) {
                const matchedIndex = this.data.deviceTypes.findIndex(
                    type => type.label.includes(res.category_name) || res.category_name.includes(type.label)
                )
                if (matchedIndex >= 0) {
                    this.setData({ deviceTypeIndex: matchedIndex })
                }
            }

            // 显示提示
            wx.showToast({
                title: '设备信息已加载',
                icon: 'success',
                duration: 2000
            })

        }).catch(err => {
            wx.hideLoading()
            console.error('加载资产信息失败:', err)

            wx.showModal({
                title: '加载失败',
                content: err.message || '无法获取设备信息，请重试',
                showCancel: false,
                success: () => {
                    // 如果加载失败，返回上一页
                    wx.navigateBack()
                }
            })
        })
    },

    // 设备类型选择
    onDeviceTypeChange(e) {
        this.setData({
            deviceTypeIndex: parseInt(e.detail.value)
        })
    },

    // 故障类型选择
    onFaultTypeChange(e) {
        this.setData({
            faultTypeIndex: parseInt(e.detail.value)
        })
    },

    // 故障描述输入
    onDescriptionInput(e) {
        this.setData({
            description: e.detail.value
        })
    },

    // 备注输入
    onRemarkInput(e) {
        this.setData({
            remark: e.detail.value
        })
    },

    // 电话输入
    onPhoneInput(e) {
        this.setData({
            phone: e.detail.value
        })
    },

    // 选择图片
    chooseImage() {
        const remainCount = this.data.maxImageCount - this.data.images.length

        wx.chooseImage({
            count: remainCount,
            sizeType: ['compressed'],
            sourceType: ['album', 'camera'],
            success: res => {
                const tempFilePaths = res.tempFilePaths

                // 添加到已选图片列表
                this.setData({
                    images: [...this.data.images, ...tempFilePaths]
                })
            }
        })
    },

    // 删除图片
    deleteImage(e) {
        const index = e.currentTarget.dataset.index
        const images = this.data.images
        images.splice(index, 1)

        this.setData({ images })
    },

    // 预览图片
    previewImage(e) {
        const url = e.currentTarget.dataset.url

        wx.previewImage({
            current: url,
            urls: this.data.images
        })
    },

    // 表单验证
    validate() {
        if (this.data.deviceTypeIndex < 0) {
            wx.showToast({
                title: '请选择设备类型',
                icon: 'none'
            })
            return false
        }

        if (this.data.faultTypeIndex < 0) {
            wx.showToast({
                title: '请选择故障类型',
                icon: 'none'
            })
            return false
        }

        if (!this.data.description.trim()) {
            wx.showToast({
                title: '请填写故障描述',
                icon: 'none'
            })
            return false
        }

        return true
    },

    // 提交报修
    async submitRepair() {
        // 验证表单
        if (!this.validate()) {
            return
        }

        // 防止重复提交
        if (this.data.submitting) {
            return
        }

        this.setData({ submitting: true })
        wx.showLoading({ title: '提交中...' })

        try {
            // 先请求订阅消息权限（使用动态获取的模板ID）
            try {
                await subscribe.requestRepairSubscribe()
            } catch (err) {
                console.log('订阅消息失败', err)
            }

            // 上传图片
            let imageUrls = []
            if (this.data.images.length > 0) {
                imageUrls = await api.uploadImages(this.data.images)
            }

            // 准备报修数据
            const repairData = {
                labId: this.data.labId,
                labName: this.data.labInfo.name,
                deviceType: this.data.deviceTypes[this.data.deviceTypeIndex].value,
                deviceTypeName: this.data.deviceTypes[this.data.deviceTypeIndex].label,
                faultType: this.data.faultTypes[this.data.faultTypeIndex].value,
                faultTypeName: this.data.faultTypes[this.data.faultTypeIndex].label,
                description: this.data.description,
                images: imageUrls,
                remark: this.data.remark,
                phone: this.data.phone,
                openid: app.globalData.openid,
                userInfo: app.globalData.userInfo,
                // 如果是通过扫码进入，添加资产ID
                assetId: this.data.assetId || null
            }

            // 提交报修单
            const result = await api.createRepairOrder(repairData)

            wx.hideLoading()

            // 提交成功
            wx.showToast({
                title: '报修成功',
                icon: 'success',
                duration: 2000
            })

            // 延迟跳转
            setTimeout(() => {
                wx.navigateTo({
                    url: `/pages/order-detail/order-detail?orderId=${result.orderId}`
                })
            }, 2000)

        } catch (err) {
            wx.hideLoading()
            console.error('提交报修失败', err)

            wx.showModal({
                title: '提交失败',
                content: err.message || '网络错误，请稍后重试',
                showCancel: false
            })
        } finally {
            this.setData({ submitting: false })
        }
    }
})
